JavaScript 异步生成器 Yield：精通流控制与背压

            async function* asyncGeneratorFunction() {
  // Asynchronous operations and yield statements
  yield await someAsyncOperation();
}

            

              
                Copy
              
            
          

            async function* numberGenerator(limit) {
  for (let i = 0; i < limit; i++) {
    await new Promise(resolve => setTimeout(resolve, 500)); // Simulate an asynchronous delay
    yield i;
  }
}

            

              
                Copy
              
            
          

            async function consumeGenerator() {
  for await (const number of numberGenerator(5)) {
    console.log(number); // Output: 0, 1, 2, 3, 4 (with 500ms delay between each)
  }
  console.log('Done!');
}

consumeGenerator();

            

              
                Copy
              
            
          

            async function* rateLimitedStream(data, rateLimit) {
  for (const item of data) {
    await new Promise(resolve => setTimeout(resolve, rateLimit));
    yield item;
  }
}

async function consumeRateLimitedStream(data, rateLimit) {
  for await (const item of rateLimitedStream(data, rateLimit)) {
    console.log('Processing:', item);
  }
}

const data = [1, 2, 3, 4, 5];
const rateLimit = 1000; // 1 second

consumeRateLimitedStream(data, rateLimit);

            

              
                Copy
              
            
          

            async function* conditionalStream(data, condition) {
  for (const item of data) {
    if (condition(item)) {
      console.log('Terminating stream...');
      return;
    }
    yield item;
  }
}

async function consumeConditionalStream(data, condition) {
  for await (const item of conditionalStream(data, condition)) {
    console.log('Processing:', item);
  }
  console.log('Stream completed.');
}

const data = [1, 2, 3, 4, 5];
const condition = (item) => item > 3;

consumeConditionalStream(data, condition);

            

              
                Copy
              
            
          

            async function* producer(consumer) {
  let i = 0;
  while (true) {
    const shouldContinue = await consumer(i);
    if (!shouldContinue) {
      console.log('Producer paused.');
      return;
    }
    yield i++;
    await new Promise(resolve => setTimeout(resolve, 100)); // Simulate some work
  }
}

async function consumer(item) {
  return new Promise(resolve => {
    setTimeout(() => {
      console.log('Consumed:', item);
      resolve(item < 10); // Stop after consuming 10 items
    }, 500);
  });
}

async function main() {
  const generator = producer(consumer);
  for await (const value of generator) {
    // No consumer-side logic needed, it's handled by the consumer function
  }
  console.log('Stream completed.');
}

main();

            

              
                Copy
              
            
          

            async function* errorProneGenerator() {
  try {
    const result = await someAsyncOperationThatMightFail();
    yield result;
  } catch (error) {
    console.error('Error:', error);
    // Decide whether to re-throw, yield a default value, or terminate the stream
    yield null; // Yield a default value and continue
    //throw error;  // Re-throw the error to terminate the stream
    //return;       // Terminate the stream gracefully
  }
}

            

              
                Copy
              
            
          

            async function* mapStream(source, transform) {
  for await (const item of source) {
    yield transform(item);
  }
}

async function* filterStream(source, filter) {
  for await (const item of source) {
    if (filter(item)) {
      yield item;
    }
  }
}

// Example usage:
async function main() {
  async function* numberGenerator(limit) {
    for (let i = 0; i < limit; i++) {
      yield i;
    }
  }

  const source = numberGenerator(10);
  const doubled = mapStream(source, (x) => x * 2);
  const evenNumbers = filterStream(doubled, (x) => x % 2 === 0);

  for await (const number of evenNumbers) {
    console.log(number); // Output: 0, 2, 4, 6, 8, 10, 12, 14, 16, 18
  }
}

main();

            

              
                Copy